// 导入全局认证管理器和API
import { authManager } from '../../api/auth-manager';
import api from '../../api/index';
import { RCSP, RCSPManager, RCSPOpAlarm } from "../../lib/rcsp-impl/rcsp";
import { DeviceManager, DeviceBluetooth, DeviceHistory, DeviceReconnect } from "../../lib/rcsp-impl/dev-bluetooth";
import { BluetoothDevice } from "../../lib/rcsp-protocol/rcsp-util";
import { wxBluetooth } from "../../lib/rcsp-impl/bluetooth";
const i18n = require('../../i18n/index');

Page({
  data: {
    // 页面标题信息
    pageTitle: '设备管理',
    pageIcon: '📱',
    pageTip: '连接和管理您的智能水杯',
    l10n: {},
    
    // 登录状态
    isLoggedIn: false,    
    
    // 设备状态
    hasDevice: false,
    isConnected: false,
    
    // 设备信息
    currentDevice: {
      deviceId: 'SWB-2024',
      name: '智能水杯Pro'
    },
    
    // 设备数据
    waterLevel: 0,
    temperature: '--',
    batteryLevel: 0,
    capacity: 600,
    drinkAmount: 0, // 🆕 添加饮水量字段
    lastSyncTime: '', // 🆕 添加上次同步时间字段
    
    // 表盘背景
    dashboardBg: '',
    dialBackgroundUrl: '', // 🆕 添加表盘背景URL字段
    
    // 设备设置（本地存储）
    autoSync: true,
    
    // 配网相关
    fromPairing: false,
    
    // 🔒 数据锁定机制
    _dataLocked: false, // 数据是否被锁定（缓存数据生效期间）
    _lastRealDataTime: 0, // 最后一次真实数据获取时间
    _cacheData: null, // 缓存的数据对象
    
      // 🔄 连接状态管理
  isReconnecting: false, // 是否正在连接中
  
  // 🔒 重试状态管理
  _isRetrying: false, // 是否正在重试中
  _retryTimeoutId: null as any, // 重试计时器ID
  _retryCount: 0, // 当前重试次数
  _maxRetryCount: 6, // 最大重试次数（增加到6次）
  
  // 🔄 上次同步结果缓存
  _lastSyncResult: null as any, // 存储上次同步的结果
  _lastTempResult: null as any, // 存储上次温度检测的结果
  
  // 🎯 原始数据解析成功标记
  _rawDataParseSuccess: false
  },

  langUnsub: null as (() => void) | null,

  _RCSPWrapperEventCallback: RCSP.RCSPWrapperEventCallback.prototype,

  // 🆕 添加原始数据解析相关属性
  originalOnReceiveData: null as ((deviceId: string, data: ArrayBuffer) => void) | null,
  pendingSync0xFFResolve: null as ((value: any) => void) | null,
  pendingSync0xFFReject: null as ((reason?: any) => void) | null,
  pendingSync0xFFAction: null as string | null,
  _lastManualSyncTime: 0,
  _lastDeviceCommandTime: 0, // 🆕 设备命令时间戳

  onLoad(options: any) {
    console.log('设备页面加载', options);
    this._updateTextsInternal();
    if (!this.langUnsub) {
      this.langUnsub = i18n.onLangChange(() => {
        this._updateTextsInternal();
      });
    }
    
    // 检查是否从配网页面返回
    if (options?.fromPairing === 'true') {
      this.setData({ fromPairing: true });
      console.log('从配网页面返回，设置fromPairing标记');
    }
    
    this.initPage();
    },
 
  _updateTextsInternal() {
    const t = (key: string, params?: any) => i18n.t(key, params);
    const l10n = {
      headerTitle: t('device.headerTitle'),
      headerTip: t('device.headerTip'),
      loginMessage: t('device.loginMessage'),
      loginDesc: t('device.loginDesc'),
      loginBtn: t('device.loginBtn'),
      noDeviceTitle: t('device.noDeviceTitle'),
      noDeviceDesc: t('device.noDeviceDesc'),
      addDeviceBtn: t('device.addDeviceBtn'),
      sectionMyDevice: t('device.sectionMyDevice'),
      deviceName: t('device.deviceName'),
      connected: t('device.connected'),
      disconnected: t('device.disconnected'),
      clickDIY: t('device.clickDIY'),
      statusWater: t('device.statusWater'),
      statusTemp: t('device.statusTemp'),
      statusBattery: t('device.statusBattery'),
      statusCapacity: t('device.statusCapacity'),
      deviceControl: t('device.deviceControl'),
      quickActions: t('device.quickActions'),
      actionSync: t('device.actionSync'),
      actionAlarm: t('device.actionAlarm'),
      actionDelete: t('device.actionDelete'),
      actionConnect: t('device.actionConnect'),
      deviceSettings: t('device.deviceSettings'),
      autoSync: t('device.autoSync'),
      autoSyncDesc: t('device.autoSyncDesc')
    };
    this.setData({ l10n });
    wx.setNavigationBarTitle({ title: t('device.title') });

    // 语言切换时，根据原始名称重新本地化设备名
    const rawName = (this.data as any).rawDeviceName || '';
    if (rawName) {
      this.setData({ 'currentDevice.name': this.localizeDeviceName(rawName) || this.data.currentDevice.name });
    }
  },

  onShow() {
    console.log('🚨 [DEBUG] 设备页面显示，fromPairing状态:', this.data.fromPairing);
    
    // 🎯 检查是否需要刷新表盘背景数据
    const shouldRefreshDialBackground = wx.getStorageSync('needRefreshDialBackground');
    console.log('🔍 [onShow] 检查表盘背景刷新标记:', shouldRefreshDialBackground);
    
    // 🎯 检查是否从其他功能页面返回（表盘背景、闹钟设置等）
    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];
    const prevPage = pages[pages.length - 2];
    
    let shouldRefreshData = false;
    
    if (prevPage) {
      const prevPageRoute = prevPage.route;
      console.log('🔍 [onShow] 上一个页面路由:', prevPageRoute);
      
      // 检查是否从设备相关功能页面返回
      if (prevPageRoute.includes('dial_add_background') || 
          prevPageRoute.includes('pageAlarmClock') ||
          prevPageRoute.includes('function_test') ||
          prevPageRoute.includes('dial_operate')) {
        shouldRefreshData = true;
        console.log('🎯 [onShow] 检测到从设备功能页面返回，需要刷新数据');
      }
    }
    
    // 🎨 如果有表盘背景刷新标记，也需要刷新数据
    if (shouldRefreshDialBackground) {
      shouldRefreshData = true;
      console.log('🎨 [onShow] 检测到表盘背景刷新标记，需要刷新数据');
      // 清除标记
      wx.removeStorageSync('needRefreshDialBackground');
    }
    
    // 更新 tabBar 选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 1 // 设备页面是第2个tab，索引为1
      });
    }
    
    // 🆕 如果需要刷新数据，先解锁数据并主动请求
    if (shouldRefreshData) {
      console.log('🔓 [onShow] 解锁数据并主动请求后端数据');
      this.unlockDeviceData();
      
      // 延迟一点时间确保页面完全显示后再请求数据
      setTimeout(() => {
        this.loadDeviceData();
        this.loadDeviceDialBackground(); // 🎨 主动请求表盘背景
      }, 300);
    } else {
      // 🆕 先加载缓存的设备数据，提升用户体验
      this.loadCachedDeviceData();
      
      // 🎨 但是表盘背景始终需要检查更新
      setTimeout(() => {
        this.loadDeviceDialBackground();
      }, 500);
    }
    
    // profile页面设置状态同步功能已移除
    
    // 🔧 临时禁用配网返回自动刷新，避免覆盖缓存数据
    if (this.data.fromPairing) {
      console.log('🚨 [DEBUG] 检测到从配网页面返回，但已禁用自动刷新以保护缓存数据');
      this.setData({ fromPairing: false });
      // ❌ 暂时注释掉自动刷新，用户可以手动同步或下拉刷新
      // setTimeout(() => {
      //   console.log('🚨 [DEBUG] 500ms延迟后调用loadDeviceData');
      //   this.loadDeviceData(); // 刷新设备列表
      // }, 500);
      
      // 🎯 给用户提示可以手动同步
      wx.showToast({
        title: i18n.t('device.pairingDone'),
        icon: 'none',
        duration: 3000
      });
    }
    
    this.checkLoginStatus();
    
    // 🆕 检查是否需要更新设备状态（设备绑定后可能需要更新hasDevice状态）
    this.checkDeviceStatusUpdate();
    
    // 🔄 刷新连接状态（确保蓝牙连接状态与页面状态同步）
    this.refreshConnectionStatus();
    
    // 🆕 如果登录了但没有设备，延迟再检查一次（可能是网络延迟）
    if (this.data.isLoggedIn && !this.data.hasDevice) {
      setTimeout(() => {
        this.checkDeviceStatusUpdate();
      }, 1000);
    }

    // ❌ 关闭自动数据监听，只保留手动同步功能
    // this.setupRawDataListener();

    // 初始化当前连接状态并注册 RCSP 事件监听
    try {
      // 避免重复注册
      if (!this._RCSPWrapperEventCallback || !(this._RCSPWrapperEventCallback instanceof RCSP.RCSPWrapperEventCallback)) {
        this._RCSPWrapperEventCallback = new RCSP.RCSPWrapperEventCallback();
        this._RCSPWrapperEventCallback.onEvent = (event) => {
          if (event.type === 'onSwitchUseDevice') {
            const device = event.onSwitchUseDeviceEvent?.device;
            const connected = !!device;
            this.setData({
              isConnected: connected,
              'currentDevice.deviceId': device?.deviceId || this.data.currentDevice.deviceId,
              'currentDevice.name': device?.name || this.data.currentDevice.name
            });
          } else if (event.type === 'onRcspInit') {
            const isInit = !!event.onRcspInitEvent?.isInit;
            const device = event.onRcspInitEvent?.device;
            this.setData({
              isConnected: isInit,
              'currentDevice.deviceId': device?.deviceId || this.data.currentDevice.deviceId,
              'currentDevice.name': device?.name || this.data.currentDevice.name
            });
          }
        };
        RCSPManager.observe(this._RCSPWrapperEventCallback);
      }

      // 从当前 RCSP 上下文初始化页面连接状态
      const curId = RCSPManager.getCurrentRcspOperateWrapper()?.deviceId || '';
      const currentlyConnected = curId !== '';
      this.setData({
        isConnected: currentlyConnected,
        'currentDevice.deviceId': currentlyConnected ? curId : this.data.currentDevice.deviceId
      });
    } catch (e) {
      console.error('初始化 RCSP 连接状态监听失败:', e);
    }
  },

  onReady() {
    console.log('设备页面就绪');
  },

  onHide() {
    console.log('设备页面隐藏');
    // 缓存当前设备数据
    this.cacheDeviceData();
  },

  onUnload() {
    console.log('设备页面卸载');
    if (this.langUnsub) {
      this.langUnsub();
      this.langUnsub = null;
    }
    try {
      if (this._RCSPWrapperEventCallback) {
        RCSPManager.removeObserve(this._RCSPWrapperEventCallback);
      }
    } catch (e) {
      console.error('移除 RCSP 连接状态监听失败:', e);
    }

    // ❌ 已关闭自动数据监听，无需清理
    // try {
    //   if (this.originalOnReceiveData && RCSPManager) {
    //     RCSPManager.onReceiveData = this.originalOnReceiveData;
    //     this.originalOnReceiveData = null;
    //     console.log('✅ 原始数据监听器已清理');
    //   }
    // } catch (error) {
    //   console.error('清理原始数据监听器失败:', error);
    // }

    // 🆕 清理pending的Promise
    if (this.pendingSync0xFFResolve) {
      this.clearPendingSync();
      console.log('✅ 已清理pending 0xFF Promise');
    }
  },

  // 初始化页面
  async initPage() {
    console.log('初始化设备页面');
    await this.checkLoginStatus();
  },

  // 检查登录状态
  checkLoginStatus() {
    try {
      const isLoggedIn = authManager.isAuthenticated();
      console.log('登录状态检查:', isLoggedIn);
      
      this.setData({
        isLoggedIn: isLoggedIn
      });

      if (isLoggedIn) {
        // 🔧 登录后自动加载设备数据
        this.loadDeviceData();
        // 消息通知设置功能已移除
      }
    } catch (error) {
      console.error('检查登录状态失败:', error);
      this.setData({
        isLoggedIn: false
      });
    }
  },

  // 🔄 刷新连接状态
  refreshConnectionStatus() {
    try {
      const curId = RCSPManager.getCurrentRcspOperateWrapper()?.deviceId || '';
      const bluetoothConnected = curId !== '';
      
      console.log('🔄 [refreshConnectionStatus] 手动刷新连接状态:', {
        currentIsConnected: this.data.isConnected,
        bluetoothConnected,
        rcspDeviceId: curId
      });
      
      if (this.data.isConnected !== bluetoothConnected) {
        this.setData({
          isConnected: bluetoothConnected
        });
        this.cacheDeviceData();
        console.log('✅ [refreshConnectionStatus] 连接状态已更新:', bluetoothConnected);
      }
    } catch (error) {
      console.error('🔄 [refreshConnectionStatus] 刷新连接状态失败:', error);
    }
  },

  // 🆕 检查设备状态更新（用于设备绑定后的状态同步）
  async checkDeviceStatusUpdate() {
    if (!this.data.isLoggedIn) return;
    
    try {
      console.log('🔍 [checkDeviceStatusUpdate] 检查设备状态更新...');
      
      // 🔧 无论数据是否锁定，都检查设备状态（用于设备绑定后的状态同步）
      const devicesResponse = await api.getDevices();
      const deviceList = devicesResponse?.data?.data || devicesResponse?.data || [];
      
      console.log('🔍 [checkDeviceStatusUpdate] 获取到设备列表:', deviceList);
      
      if (Array.isArray(deviceList) && deviceList.length > 0) {
        const hasDevice = true;
        const currentHasDevice = this.data.hasDevice;
        const device = deviceList[0];
        
        // 🔧 检查蓝牙连接状态（无论是否已有设备）
        const curId = RCSPManager.getCurrentRcspOperateWrapper()?.deviceId || '';
        const bluetoothConnected = curId !== '';
        const serverOnlineStatus = device.isOnline === 1;
        
        // 🔧 优先使用蓝牙连接状态，如果蓝牙未连接则使用服务器状态
        const actualConnectedStatus = bluetoothConnected || serverOnlineStatus;
        
        console.log('🔍 [checkDeviceStatusUpdate] 连接状态检查:', {
          bluetoothConnected,
          serverOnlineStatus,
          actualConnectedStatus,
          currentIsConnected: this.data.isConnected
        });
        
        if (!currentHasDevice) {
          console.log('✅ [checkDeviceStatusUpdate] 发现新设备，更新hasDevice状态');
          
          // 更新设备状态
          this.setData({
            hasDevice: true,
            currentDevice: {
              deviceId: device.deviceSn || device.deviceId || 'SWB-2024',
              name: device.deviceName || '智能水杯Pro'
            },
            isConnected: actualConnectedStatus
          });
          
          // 缓存更新后的数据
          this.cacheDeviceData();
          
          console.log('🎉 [checkDeviceStatusUpdate] 设备状态已更新，hasDevice:', true, 'isConnected:', actualConnectedStatus);
          
          // 🎯 新设备连接成功后，自动触发同步数据
          setTimeout(() => {
            console.log('🔄 [auto-sync] 检测到新设备，自动触发同步数据');
            this.syncData();
          }, 1500); // 给设备状态更新一点时间
        } else {
          // 🔧 即使hasDevice已为true，也要检查并更新连接状态
          if (this.data.isConnected !== actualConnectedStatus) {
            console.log('🔄 [checkDeviceStatusUpdate] 更新连接状态:', this.data.isConnected, '->', actualConnectedStatus);
            this.setData({
              isConnected: actualConnectedStatus
            });
            this.cacheDeviceData();
          } else {
            console.log('ℹ️ [checkDeviceStatusUpdate] 设备状态无需更新，hasDevice已为true，连接状态正确');
          }
        }
      } else {
        console.log('ℹ️ [checkDeviceStatusUpdate] 未发现设备');
      }
    } catch (error) {
      console.error('🔍 [checkDeviceStatusUpdate] 检查设备状态失败:', error);
    }
  },

  // 🆕 加载缓存的设备数据
  loadCachedDeviceData() {
    try {
      const cachedDeviceData = wx.getStorageSync('deviceData');
      if (cachedDeviceData) {
        console.log('📋 加载缓存的设备数据:', cachedDeviceData);
        
        // 🔒 锁定数据，防止被其他操作覆盖
        this.setData({
          _dataLocked: true,
          _cacheData: cachedDeviceData,
          hasDevice: cachedDeviceData.hasDevice || false,
          currentDevice: cachedDeviceData.currentDevice || {
            deviceId: 'SWB-2024',
            name: '智能水杯Pro'
          },
          waterLevel: cachedDeviceData.waterLevel || 0,
          temperature: cachedDeviceData.temperature || '--',
          batteryLevel: cachedDeviceData.batteryLevel || 0,
          capacity: cachedDeviceData.capacity || 600,
          drinkAmount: cachedDeviceData.drinkAmount || 0,
          lastSyncTime: cachedDeviceData.lastSyncTime || '',
          // 🎨 从缓存恢复表盘背景URL，确保数据锁定时能正常显示
          dialBackgroundUrl: cachedDeviceData.dialBackgroundUrl || '',
          dashboardBg: cachedDeviceData.dashboardBg || '',
          // 🆕 加载缓存的设备设置状态
          autoSync: cachedDeviceData.autoSync !== undefined ? cachedDeviceData.autoSync : true
        });
        
        console.log('🔒 缓存设备数据已加载并锁定，表盘背景已从缓存恢复:', {
          autoSync: this.data.autoSync,
          dataLocked: this.data._dataLocked,
          dialBackgroundUrl: cachedDeviceData.dialBackgroundUrl || '无缓存'
        });
      } else {
        console.log('⚠️ 没有找到缓存的设备数据');
      }
    } catch (error) {
      console.error('❌ 加载缓存设备数据失败:', error);
    }
  },

  // 🆕 缓存设备数据
  cacheDeviceData() {
    try {
      // 🚨 重要：只缓存有效的数据，避免缓存无效的采集错误数据
      const deviceData = {
        hasDevice: this.data.hasDevice,
        currentDevice: this.data.currentDevice,
        waterLevel: this.data.waterLevel,
        temperature: this.data.temperature,
        batteryLevel: this.data.batteryLevel,
        capacity: this.data.capacity,
        drinkAmount: this.data.drinkAmount,
        lastSyncTime: this.data.lastSyncTime,
        // 🎨 表盘背景URL也加入缓存，确保数据锁定时能正常显示
        dialBackgroundUrl: this.data.dialBackgroundUrl,
        dashboardBg: this.data.dashboardBg,
        // 🆕 添加设备设置状态缓存
        autoSync: this.data.autoSync,
        cachedAt: new Date().toISOString()
      };
      
      wx.setStorageSync('deviceData', deviceData);
      console.log('💾 设备数据已缓存（包含表盘背景）:', deviceData);
    } catch (error) {
      console.error('❌ 缓存设备数据失败:', error);
    }
  },

  // 🔒 安全更新设备数据（带锁定检查）
  safeUpdateDeviceData(newData: any, source: string = 'unknown') {
    // 如果数据被锁定且不是真实数据源，则跳过更新
    if (this.data._dataLocked && source !== 'real_data') {
      console.log(`🔒 [safeUpdateDeviceData] 数据已锁定，跳过${source}的更新:`, newData);
      return false;
    }
    
    // 如果是真实数据，解锁并更新
    if (source === 'real_data') {
      console.log(`✅ [safeUpdateDeviceData] 收到真实数据，解锁并更新:`, newData);
      this.setData({
        _dataLocked: false,
        _lastRealDataTime: Date.now(),
        ...newData
      });
      return true;
    }
    
    // 其他情况正常更新
    console.log(`📝 [safeUpdateDeviceData] 正常更新数据(${source}):`, newData);
    this.setData(newData);
    return true;
  },

  // 加载设备数据
  async loadDeviceData() {
    if (!this.data.isLoggedIn) return;

    // 🔒 检查数据锁定状态
    if (this.data._dataLocked) {
      console.log('🔒 [loadDeviceData] 数据已锁定，跳过加载');
      return;
    }

    try {
      console.log('🔄 [loadDeviceData] 开始加载设备数据...');
      this.setData({ isLoading: true });
      
      // 🔧 使用现有的 API 调用方式
      const devicesResponse = await api.getDevices();
      console.log('📋 [loadDeviceData] 设备列表响应:', devicesResponse);
      
      // 安全地获取设备数据
      const deviceList = devicesResponse?.data?.data || devicesResponse?.data || [];
      console.log('解析的设备列表:', deviceList);
      
      if (Array.isArray(deviceList) && deviceList.length > 0) {
        const devices = deviceList;
        const hasDevice = devices.length > 0;
        
        this.setData({
          hasDevice: hasDevice,
          isLoading: false
        });
        
        if (hasDevice) {
          // 🎯 设置设备信息
          const currentDevice = devices[0]; // 使用第一个设备
          
          // 🔧 更新设备数据，但保留实时数据
          const rawName = currentDevice.deviceName || currentDevice.name || '';
          const updateData: any = {
            currentDevice: {
              deviceId: currentDevice.deviceSn || currentDevice.deviceId || 'SWB-2024',
              name: this.localizeDeviceName(rawName) || i18n.t('device.deviceName')
            },
            devices: devices,
            isConnected: currentDevice.isOnline === 1,
            capacity: 600, // 默认容量
            rawDeviceName: rawName
          };
          
          // 🎨 处理表盘背景URL - 始终主动请求最新数据
          if (currentDevice.dialBackgroundUrl || currentDevice.dial_background_url) {
            const backgroundUrl = currentDevice.dialBackgroundUrl || currentDevice.dial_background_url;
            console.log('🎨 [loadDeviceData] 发现表盘背景URL:', backgroundUrl);
            updateData.dialBackgroundUrl = backgroundUrl;
            updateData.dashboardBg = `url("${backgroundUrl}")`;
          } else {
            console.log('🎨 [loadDeviceData] 未发现表盘背景URL，主动请求最新数据');
            updateData.dialBackgroundUrl = '';
            updateData.dashboardBg = '';
            // 主动请求表盘背景数据
            setTimeout(() => {
              this.loadDeviceDialBackground();
            }, 500);
          }
          
          // 🆕 只有当没有实时数据时，才使用数据库数据
          if (this.data.batteryLevel === 0 || this.data.batteryLevel === null) {
            updateData.batteryLevel = currentDevice.batteryLevel || 0;
          }
          if (this.data.waterLevel === 0 || this.data.waterLevel === null) {
            updateData.waterLevel = currentDevice.currentVolume || 0;
          }
          if (this.data.temperature === '--' || this.data.temperature === null || this.data.temperature === undefined) {
            updateData.temperature = currentDevice.waterTemperature || '--';
          }
          
          this.setData(updateData);
        
        // 🆕 缓存设备数据 - 但只有当数据看起来合理时才缓存
        // 检查温度是否为明显的异常值（比如-17°C），如果是则不缓存，保持之前的有效缓存
        const currentTemp = this.data.temperature;
        const shouldCache = !(typeof currentTemp === 'string' && 
                            currentTemp !== '--' && 
                            !isNaN(Number(currentTemp)) && 
                            Number(currentTemp) < 0);
        
        if (shouldCache) {
          this.cacheDeviceData();
          console.log('✅ [loadDeviceData] 数据已缓存');
        } else {
          console.log('⚠️ [loadDeviceData] 检测到异常温度值，跳过缓存以保护有效数据');
        }
        
          console.log('✅ [loadDeviceData] 设备信息已更新:', {
            deviceName: currentDevice.deviceName,
            isConnected: currentDevice.isOnline === 1,
            batteryLevel: currentDevice.batteryLevel,
            waterLevel: currentDevice.currentVolume
          });
          
          // 数据加载后重新同步RCSP连接状态
        this.syncRCSPConnectionStatus();
      } else {
          // 🔧 没有设备时，只更新hasDevice状态，不覆盖其他缓存数据
      console.log('用户暂无设备，保持当前数据不变');
      this.setData({
        hasDevice: false,
        isConnected: false
      });
        
          // 🆕 缓存当前状态
          this.cacheDeviceData();
        }
      } else {
        console.log('❌ [loadDeviceData] 用户暂无设备');
          this.setData({
          hasDevice: false,
          isConnected: false,
          isLoading: false
          });
        }
        
    } catch (error) {
      console.error('❌ [loadDeviceData] 加载设备数据失败:', error);
      this.setData({
        isLoading: false,
        hasDevice: false
      });
      
      // 🆕 出错时尝试使用缓存数据
      this.loadCachedDeviceData();
      
      wx.showToast({
        title: i18n.t('device.stateFailed'),
        icon: 'none'
      });
    }
  },
  
  // 跳转到登录页面
  goToLogin() {
    wx.navigateTo({
      url: '/pages/login/login'
    });
  },
  
  // 添加设备 - 跳转到设备配置页面
  addDevice() {
    console.log('跳转到添加设备页面');
    
    // 跳转到设备配置页面 (index_test)
    wx.navigateTo({
      url: '/pages/index_test/index?fromDevice=true',
      success: () => {
        console.log('成功跳转到添加设备页面');
      },
      fail: (error) => {
        console.error('跳转添加设备页面失败:', error);
        wx.showToast({
        title: i18n.t('device.jumpFailed'),
        icon: 'error'
      });
      }
    });
  },

  // 🔗 连接设备 - 简化版本
  connectDevice() {
    this.ensureLang();
    console.log('🔗 [connectDevice] 开始连接设备流程');
    
    // 检查当前连接状态
    const current = RCSPManager.getCurrentRcspOperateWrapper && RCSPManager.getCurrentRcspOperateWrapper();
    if (current && current.deviceId) {
      console.log('✅ [connectDevice] 设备已连接:', current.deviceId);
      wx.showToast({
        title: i18n.t('device.connectAlready'),
        icon: 'success'
      });
      // 刷新设备状态并同步数据
      this.refreshConnectionStatus();
      setTimeout(() => {
        this.syncData();
      }, 1000);
      return;
    }
    
    // 显示加载提示
    wx.showLoading({
      title: i18n.t('device.connecting'),
      mask: true
    });
    
    // 尝试直接连接设备
    this.tryDirectConnect();
  },

  // 尝试直接连接设备
  tryDirectConnect() {
    console.log('🎯 [tryDirectConnect] 尝试直接连接设备');
    
    try {
      // 方法1: 尝试从历史记录获取设备信息
      const historyDevices = DeviceHistory.getHistoryRecordList && DeviceHistory.getHistoryRecordList();
      if (historyDevices && historyDevices.length > 0) {
        const lastDevice = historyDevices[historyDevices.length - 1];
        console.log('📱 [tryDirectConnect] 从历史记录获取设备:', lastDevice);
        
        // 构造设备对象
        const device = new BluetoothDevice();
        device.deviceId = lastDevice.address;
        device.name = lastDevice.name || '智能水杯';
        device.localName = lastDevice.name || '智能水杯';
        device.RSSI = 0;
        device.connectable = true;
        device.serviceData = {};
        
        console.log('🔗 [tryDirectConnect] 尝试连接设备:', device);
        DeviceManager.connecDevice(device);
        
        // 设置连接超时
        setTimeout(() => {
          this.checkConnectionResult();
        }, 8000);
        
        return;
      }
      
      // 方法2: 尝试从已连接设备列表获取
      const connectedDevices = wxBluetooth.bleConnect.getConnectedDeviceIds && wxBluetooth.bleConnect.getConnectedDeviceIds();
      if (connectedDevices && connectedDevices.length > 0) {
        console.log('📱 [tryDirectConnect] 发现已连接设备:', connectedDevices);
        const device = connectedDevices[0];
        console.log('🔗 [tryDirectConnect] 使用已连接设备:', device);
        
        // 直接使用已连接设备
        setTimeout(() => {
          this.checkConnectionResult();
        }, 1000);
        
        return;
      }
      
      // 方法3: 尝试从缓存获取设备ID
      const cachedDeviceId = wx.getStorageSync('rcsp:lastDeviceId');
      if (cachedDeviceId) {
        console.log('📱 [tryDirectConnect] 从缓存获取设备ID:', cachedDeviceId);
        
        const device = new BluetoothDevice();
        device.deviceId = cachedDeviceId;
        device.name = '智能水杯';
        device.localName = '智能水杯';
        device.RSSI = 0;
        device.connectable = true;
        device.serviceData = {};
        
        console.log('🔗 [tryDirectConnect] 尝试连接缓存设备:', device);
        DeviceManager.connecDevice(device);
        
        // 设置连接超时
        setTimeout(() => {
          this.checkConnectionResult();
        }, 8000);
        
        return;
      }
      
      // 方法4: 启动扫描并连接
      console.log('🔍 [tryDirectConnect] 启动扫描连接');
      this.startScanAndConnect();
      
    } catch (error) {
      console.error('❌ [tryDirectConnect] 直接连接失败:', error);
      this.handleConnectionFailure();
    }
  },

  // 检查连接结果
  checkConnectionResult() {
    console.log('🔍 [checkConnectionResult] 检查连接结果');
    
    const current = RCSPManager.getCurrentRcspOperateWrapper && RCSPManager.getCurrentRcspOperateWrapper();
    if (current && current.deviceId) {
      console.log('✅ [checkConnectionResult] 连接成功:', current.deviceId);
      wx.hideLoading();
      this.handleConnectionSuccess(current.deviceId);
    } else {
      console.log('❌ [checkConnectionResult] 连接失败，尝试扫描连接');
      this.startScanAndConnect();
    }
  },

  // 启动扫描并连接
  startScanAndConnect() {
    console.log('🔍 [startScanAndConnect] 启动扫描连接');
    
    // 设置扫描超时
    const scanTimeout = setTimeout(() => {
      console.log('⏰ [startScanAndConnect] 扫描超时');
      this.handleConnectionFailure();
    }, 15000);
    
    // 监听设备发现
    const deviceFoundHandler = (event: any) => {
      if (event.type === 'onDiscovery') {
        const device = event.onDiscoveryEvent?.device;
        if (device) {
          console.log('📱 [startScanAndConnect] 发现设备:', device);
          
          // 检查是否是目标设备
          if (this.isTargetDevice(device)) {
            console.log('🎯 [startScanAndConnect] 找到目标设备，开始连接');
            clearTimeout(scanTimeout);
            DeviceManager.removeObserve(deviceFoundHandler);
            
            DeviceManager.connecDevice(device);
            
            // 设置连接超时
            setTimeout(() => {
              this.checkConnectionResult();
            }, 8000);
          }
        }
      }
    };
    
    // 添加设备发现监听
    DeviceManager.observe(deviceFoundHandler);
    
    // 开始扫描
    DeviceManager.starScan();
  },

  // 检查是否是目标设备
  isTargetDevice(device: any): boolean {
    // 检查设备名称
    if (device.name && (
      device.name.includes('JL707') || 
      device.name.includes('watch') || 
      device.name.includes('水杯') ||
      device.name.includes('Smart')
    )) {
      return true;
    }
    
    // 检查设备ID格式
    if (device.deviceId && device.deviceId.length > 20) {
      return true;
    }
    
    return false;
  },

  // 处理连接成功
  handleConnectionSuccess(deviceId: string) {
    console.log('✅ [handleConnectionSuccess] 设备连接成功:', deviceId);
    
    // 更新连接状态
    this.setData({
      isConnected: true,
      isReconnecting: false
    });
    
    // 刷新设备信息
    this.refreshConnectionStatus();
    
    // 同步设备数据
    setTimeout(() => {
      this.syncData();
    }, 1000);
    
    wx.showToast({
      title: i18n.t('device.connectSuccess'),
      icon: 'success'
    });
  },

  // 🔗 仅连接设备（不发送同步数据命令）
  connectDeviceOnly() {
    this.ensureLang();
    console.log('🔗 [connectDeviceOnly] 开始仅连接设备流程');
    
    // 检查当前连接状态
    const current = RCSPManager.getCurrentRcspOperateWrapper && RCSPManager.getCurrentRcspOperateWrapper();
    if (current && current.deviceId) {
      console.log('✅ [connectDeviceOnly] 设备已连接:', current.deviceId);
      wx.showToast({
        title: i18n.t('device.connectAlready'),
        icon: 'success'
      });
      // 刷新设备状态
      this.refreshConnectionStatus();
      return;
    }
    
    // 显示加载提示
    wx.showLoading({
      title: i18n.t('device.connecting'),
      mask: true
    });
    
    // 尝试直接连接设备
    this.tryDirectConnectOnly();
  },

  // 尝试直接连接设备（仅连接版本）
  tryDirectConnectOnly() {
    console.log('🎯 [tryDirectConnectOnly] 尝试直接连接设备（仅连接）');
    
    try {
      // 方法1: 尝试从历史记录获取设备信息
      const historyDevices = DeviceHistory.getHistoryRecordList && DeviceHistory.getHistoryRecordList();
      if (historyDevices && historyDevices.length > 0) {
        const lastDevice = historyDevices[historyDevices.length - 1];
        console.log('📱 [tryDirectConnectOnly] 从历史记录获取设备:', lastDevice);
        
        // 构造设备对象
        const device = new BluetoothDevice();
        device.deviceId = lastDevice.address;
        device.name = lastDevice.name || '智能水杯';
        device.localName = lastDevice.name || '智能水杯';
        device.RSSI = 0;
        device.connectable = true;
        device.serviceData = {};
        
        console.log('🔗 [tryDirectConnectOnly] 尝试连接设备:', device);
        DeviceManager.connecDevice(device);
        
        // 设置连接超时
        setTimeout(() => {
          this.checkConnectionResultOnly();
        }, 8000);
        
        return;
      }
      
      // 方法2: 尝试从已连接设备列表获取
      const connectedDevices = wxBluetooth.bleConnect.getConnectedDeviceIds && wxBluetooth.bleConnect.getConnectedDeviceIds();
      if (connectedDevices && connectedDevices.length > 0) {
        console.log('📱 [tryDirectConnectOnly] 发现已连接设备:', connectedDevices);
        const device = connectedDevices[0];
        console.log('🔗 [tryDirectConnectOnly] 使用已连接设备:', device);
        
        // 直接使用已连接设备
        setTimeout(() => {
          this.checkConnectionResultOnly();
        }, 1000);
        
        return;
      }
      
      // 方法3: 尝试从缓存获取设备ID
      const cachedDeviceId = wx.getStorageSync('rcsp:lastDeviceId');
      if (cachedDeviceId) {
        console.log('📱 [tryDirectConnectOnly] 从缓存获取设备ID:', cachedDeviceId);
        
        const device = new BluetoothDevice();
        device.deviceId = cachedDeviceId;
        device.name = '智能水杯';
        device.localName = '智能水杯';
        device.RSSI = 0;
        device.connectable = true;
        device.serviceData = {};
        
        console.log('🔗 [tryDirectConnectOnly] 尝试连接缓存设备:', device);
        DeviceManager.connecDevice(device);
        
        // 设置连接超时
        setTimeout(() => {
          this.checkConnectionResultOnly();
        }, 8000);
        
        return;
      }
      
      // 方法4: 启动扫描并连接
      console.log('🔍 [tryDirectConnectOnly] 启动扫描连接');
      this.startScanAndConnectOnly();
      
    } catch (error) {
      console.error('❌ [tryDirectConnectOnly] 直接连接失败:', error);
      this.handleConnectionFailureOnly();
    }
  },

  // 检查连接结果（仅连接版本）
  checkConnectionResultOnly() {
    console.log('🔍 [checkConnectionResultOnly] 检查连接结果');
    
    const current = RCSPManager.getCurrentRcspOperateWrapper && RCSPManager.getCurrentRcspOperateWrapper();
    if (current && current.deviceId) {
      console.log('✅ [checkConnectionResultOnly] 连接成功:', current.deviceId);
      wx.hideLoading();
      this.handleConnectionSuccessOnly(current.deviceId);
    } else {
      console.log('❌ [checkConnectionResultOnly] 连接失败，尝试扫描连接');
      this.startScanAndConnectOnly();
    }
  },

  // 启动扫描并连接（仅连接版本）
  startScanAndConnectOnly() {
    console.log('🔍 [startScanAndConnectOnly] 启动扫描连接');
    
    // 设置扫描超时
    const scanTimeout = setTimeout(() => {
      console.log('⏰ [startScanAndConnectOnly] 扫描超时');
      this.handleConnectionFailureOnly();
    }, 15000);
    
    // 监听设备发现
    const deviceFoundHandler = (event: any) => {
      if (event.type === 'onDiscovery') {
        const device = event.onDiscoveryEvent?.device;
        if (device) {
          console.log('📱 [startScanAndConnectOnly] 发现设备:', device);
          
          // 检查是否是目标设备
          if (this.isTargetDevice(device)) {
            console.log('🎯 [startScanAndConnectOnly] 找到目标设备，开始连接');
            clearTimeout(scanTimeout);
            DeviceManager.removeObserve(deviceFoundHandler);
            
            DeviceManager.connecDevice(device);
            
            // 设置连接超时
            setTimeout(() => {
              this.checkConnectionResultOnly();
            }, 8000);
          }
        }
      }
    };
    
    // 添加设备发现监听
    DeviceManager.observe(deviceFoundHandler);
    
    // 开始扫描
    DeviceManager.starScan();
  },

  // 处理连接成功（仅连接版本）
  handleConnectionSuccessOnly(deviceId: string) {
    console.log('✅ [handleConnectionSuccessOnly] 设备连接成功（仅连接）:', deviceId);
    
    // 更新连接状态
    this.setData({
      isConnected: true,
      isReconnecting: false
    });
    
    // 刷新设备信息
    this.refreshConnectionStatus();
    
    // ❌ 不发送同步数据命令
    // setTimeout(() => {
    //   this.syncData();
    // }, 1000);
    
    wx.showToast({
      title: i18n.t('device.connectSuccess'),
      icon: 'success'
    });
  },

  // 处理连接失败（仅连接版本）
  handleConnectionFailureOnly() {
    console.log('❌ [handleConnectionFailureOnly] 设备连接失败');
    
    wx.hideLoading();
    
    this.setData({
      isReconnecting: false
    });
    
    wx.showModal({
      title: i18n.t('device.connectFailedTitle'),
      content: i18n.t('device.connectFailedContent'),
      confirmText: this._btn(i18n.t('device.retry'), 'OK'),
      cancelText: this._btn(i18n.t('common.cancel'), 'Back'),
      success: (res) => {
        if (res.confirm) {
          this.connectDeviceOnly();
        }
      }
    });
  },

  // 处理连接失败
  handleConnectionFailure() {
    console.log('❌ [handleConnectionFailure] 设备连接失败');
    
    wx.hideLoading();
    
    this.setData({
      isReconnecting: false
    });
    
    wx.showModal({
      title: i18n.t('device.connectFailedTitle'),
      content: i18n.t('device.connectFailedContent'),
      confirmText: this._btn(i18n.t('device.retry'), 'OK'),
      cancelText: this._btn(i18n.t('common.cancel'), 'Back'),
      success: (res) => {
        if (res.confirm) {
          this.connectDevice();
        }
      }
    });
  },

  // 手动搜索设备
  manualSearchDevice() {
    console.log('🔍 [manualSearchDevice] 开始手动搜索设备');
    wx.showLoading({
      title: '搜索设备中...'
    });
    
    // 启动扫描
    DeviceManager.starScan();
    
    // 设置扫描超时
    setTimeout(() => {
      DeviceManager.stopScan();
      wx.hideLoading();
      
      wx.showToast({
        title: '搜索完成',
        icon: 'success'
      });
    }, 10000);
  },
  
  // 🎨 加载设备表盘背景 - 实时请求不使用缓存
  async loadDeviceDialBackground() {
    if (!this.data.hasDevice || !this.data.currentDevice.deviceId) {
      console.log('🎨 [loadDeviceDialBackground] 没有设备，跳过加载表盘背景');
      return;
    }

    try {
      console.log('🎨 [loadDeviceDialBackground] 开始实时加载设备表盘背景');
      const deviceId = this.data.currentDevice.deviceId;
      
      const response = await api.getDeviceDialBackground(deviceId);
      const backgroundData = response?.data?.data || response?.data;
      
      if (backgroundData && backgroundData.dialBackgroundUrl) {
        console.log('🎨 [loadDeviceDialBackground] 成功获取表盘背景URL:', backgroundData.dialBackgroundUrl);
        
        // 🎯 实时更新表盘背景，不受数据锁定影响
        this.setData({
          dialBackgroundUrl: backgroundData.dialBackgroundUrl,
          dashboardBg: `url("${backgroundData.dialBackgroundUrl}")`
        });
        
        console.log('✅ [loadDeviceDialBackground] 表盘背景已实时更新');
      } else {
        console.log('🎨 [loadDeviceDialBackground] 专用API未获取到表盘背景URL，检查是否已有URL');
        // 🎯 如果专用API没有数据，但当前已有表盘背景URL（可能来自设备列表），则保持不变
        if (!this.data.dialBackgroundUrl) {
          console.log('🎨 [loadDeviceDialBackground] 当前无表盘背景，设置为默认状态');
          this.setData({
            dialBackgroundUrl: '',
            dashboardBg: ''
          });
        } else {
          console.log('🎨 [loadDeviceDialBackground] 保持现有表盘背景URL:', this.data.dialBackgroundUrl);
        }
      }
    } catch (error) {
      console.error('🎨 [loadDeviceDialBackground] 加载表盘背景失败:', error);
      // 失败时保持默认状态
      this.setData({
        dialBackgroundUrl: '',
        dashboardBg: ''
      });
    }
  },

  // 选择表盘图片 - 跳转到表盘背景添加页面
  chooseImage() {
    console.log('跳转到表盘背景添加页面');
    
    // 检查是否有设备连接
    if (!this.data.isConnected) {
      wx.showToast({
        title: i18n.t('device.pleaseConnect'),
        icon: 'none'
      });
      return;
    }
    
    // 跳转到表盘背景添加页面
    wx.navigateTo({
      url: '/pages/function_test/dial_operate/dial_add_background/index?fromDevice=true',
      success: () => {
        console.log('成功跳转到表盘背景添加页面');
      },
      fail: (error) => {
        console.error('跳转表盘背景添加页面失败:', error);
        wx.showToast({
          title: i18n.t('device.jumpFailed'),
          icon: 'error'
        });
      }
    });
  },
  
  // 🆕 设置原始数据监听器
  setupRawDataListener() {
    try {
      console.log('🔗 设置原始数据监听器');
      
      if (!RCSPManager) {
        console.warn('RCSPManager 不可用');
        return;
      }
      
      // 保存原始的onReceiveData方法
      if (!this.originalOnReceiveData && RCSPManager.onReceiveData) {
        this.originalOnReceiveData = RCSPManager.onReceiveData.bind(RCSPManager);
        
        // 重写onReceiveData方法来拦截数据
        RCSPManager.onReceiveData = (deviceId: string, data: ArrayBuffer) => {
          try {
            // 将ArrayBuffer转换为十六进制字符串
            const hexString = this.arrayBufferToHex(data);
            console.log('📡 拦截到原始数据:', hexString);
            
            // 检查是否是0xFF命令的响应
            if (hexString.toLowerCase().includes('fedcbac0ff000b')) {
              console.log('🎯 发现0xFF命令响应，解析数据...');
              this.parseHexData(hexString);
            }
            
            // 调用原始方法继续正常处理
            return this.originalOnReceiveData!(deviceId, data);
          } catch (error) {
            console.error('处理原始数据时出错:', error);
            // 发生错误时仍然调用原始方法
            return this.originalOnReceiveData!(deviceId, data);
          }
        };
        
        console.log('✅ 原始数据监听器已设置');
      }
      
    } catch (error) {
      console.error('设置原始数据监听器失败:', error);
    }
  },

  // 🆕 清理原始数据监听器
  cleanupRawDataListener() {
    try {
      if (this.originalOnReceiveData && RCSPManager) {
        RCSPManager.onReceiveData = this.originalOnReceiveData;
        this.originalOnReceiveData = null;
        console.log('✅ 原始数据监听器已清理');
      }
    } catch (error) {
      console.error('清理原始数据监听器失败:', error);
    }
  },

  // 🆕 ArrayBuffer转十六进制字符串
  arrayBufferToHex(buffer: ArrayBuffer): string {
    const byteArray = new Uint8Array(buffer);
    const hexCodes: string[] = [];
    for (let i = 0; i < byteArray.length; i++) {
      const value = byteArray[i];
      const hexCode = value.toString(16).padStart(2, '0');
      hexCodes.push(hexCode);
    }
    return hexCodes.join('');
  },

  // 🆕 原始数据解析（核心方法）
  parseHexData(hexString: string) {
    try {
      // 🎯 直接寻找0xFF命令的响应数据模式
      // 模式说明：
      // - fedcbac0ff000b是命令头部
      // - 后面2个十六进制字符是时间戳
      // - 接下来的数据是设备数据
      // - 第1-4字节：温度、水位、饮水量低字节、饮水量高字节
      // - 第5字节：电池电量级别
      // - 第6字节：保留
      // - 第7字节：状态位（01=数据采集错误，00=数据正常）
      // 查找0xFF命令的响应模式
      const ffPattern = /fedcbac0ff000b[0-9a-f]{2}([0-9a-f]+)/i;
      const match = hexString.match(ffPattern);
      
      if (match && match[1]) {
        const dataHex = match[1];
        console.log('🎯 提取到0xFF响应数据:', dataHex);
        
        // 🔧 数据长度检查：确保数据足够长度进行解析
        if (dataHex.length >= 8) {
          console.log(`🔍 数据长度检查通过：${dataHex.length}个字符 >= 8个字符`);
          console.log(`🔍 完整数据：${dataHex}`);
          
          // 只取前8个字节（4个数据字节）
          const dataBytes = dataHex.substring(0, 8);
          if (dataBytes.length >= 8) {
            // 解析十六进制数据为字节数组
            const byte0 = parseInt(dataBytes.substring(0, 2), 16); // 温度原始值（需要减去40）
            const byte1 = parseInt(dataBytes.substring(2, 4), 16); // 水位百分比
            const byte2 = parseInt(dataBytes.substring(4, 6), 16); // 饮水量低字节
            const byte3 = parseInt(dataBytes.substring(6, 8), 16); // 饮水量高字节
            
            // 🌡️ 温度解析：原始值减去40得到实际温度
            const temperature = byte0 - 40; // 温度范围：-40到125°C
            
            // 💧 水位百分比解析：直接使用byte1的值
            const waterLevel = byte1; // 水位百分比 0-100%
            
            // 🥤 饮水量解析：低字节+高字节组合
            const drinkAmount = byte2 + (byte3 << 8); // 组合成16位值
            
            // 🔋 电池电量解析：第5个字节位置的电量数据
            let batteryLevel = 0;
            const fullDataLength = dataHex.length;
            
            // 🔧 修复：第5个字节 = 第8-9个十六进制字符 (位置从0开始)
            if (fullDataLength >= 10) {
              const batteryByte = parseInt(dataHex.substring(8, 10), 16); // 第5个字节
              // 电量映射：根据固件逻辑 4=80-100%, 3=60-79%, 2=40-59%, 1=20-39%, 0=0-19%
              if (batteryByte >= 4) {
                batteryLevel = 100; // 代表80-100%，显示100%
              } else if (batteryByte >= 3) {
                batteryLevel = 70; // 代表60-79%，显示70%
              } else if (batteryByte >= 2) {
                batteryLevel = 50; // 代表40-59%，显示50%
              } else if (batteryByte >= 1) {
                batteryLevel = 30; // 代表20-39%，显示30%
              } else {
                batteryLevel = 10; // 代表0-19%，显示10%
              }
            }
            
            // 🔍 检查第7个字节的状态位（数据有效性）
            let isDataValid = true;
            let statusByte = 0;
            if (fullDataLength >= 14) {
              statusByte = parseInt(dataHex.substring(12, 14), 16); // 第7个字节
              isDataValid = (statusByte !== 1); // 01表示数据采集错误
              console.log(`🔍 第7字节状态检查: 0x${statusByte.toString(16).toUpperCase()} -> ${isDataValid ? '数据有效' : '数据采集错误'}`);
            }
            
            console.log('📊 0xFF命令解析结果:');
            console.log(`   🌡️ 水温: ${temperature}°C (原始值: 0x${byte0.toString(16).toUpperCase()})`);
            console.log(`   💧 水位: ${waterLevel}% (原始值: 0x${byte1.toString(16).toUpperCase()})`);
            console.log(`   🥤 饮水量: ${drinkAmount}ml (低字节: 0x${byte2.toString(16).toUpperCase()}, 高字节: 0x${byte3.toString(16).toUpperCase()})`);
            
            // 🔋 显示正确的电池电量解析信息
            if (fullDataLength >= 10) {
              const batteryByte = parseInt(dataHex.substring(8, 10), 16);
              console.log(`   🔋 电池电量: ${batteryLevel}% (第5字节原始值: 0x${batteryByte.toString(16).toUpperCase()}, 级别: ${batteryByte})`);
            } else {
              console.log(`   🔋 电池电量: ${batteryLevel}% (数据不足)`);
            }
            
            // 📦 构造设备数据对象
            const deviceData = {
              temperature: temperature.toString(),
              waterLevel: waterLevel,
              drinkAmount: drinkAmount,
              batteryLevel: batteryLevel
            };
            
            // 🎯 处理pending的0xFF命令（无论数据是否有效都要响应命令）
            if (this.pendingSync0xFFResolve) {
              console.log(`✅ 收到${this.pendingSync0xFFAction || '0xFF命令'}响应，状态: ${isDataValid ? '数据有效' : '数据采集错误'}`);
              
              if (isDataValid) {
                // 🔄 数据有效：正常更新UI和缓存
                this.safeUpdateDeviceData({
                  ...deviceData,
                  lastSyncTime: new Date().toLocaleTimeString()
                }, 'real_data');
                
                // 立即缓存更新后的设备数据
                this.cacheDeviceData();
                
                // ✅ 数据有效，清理重试状态，标记解析成功
                if (this.data._retryTimeoutId) {
                  clearTimeout(this.data._retryTimeoutId);
                }
                this.setData({
                  _retryCount: 0,
                  _isRetrying: false,
                  _retryTimeoutId: null,
                  _rawDataParseSuccess: true // 🎯 标记原始数据解析成功
                });
                
                console.log(`📱 数据有效，已更新页面显示和缓存`);
              } else {
                // ⚠️ 数据无效：不更新UI和缓存
                console.log(`⚠️ 第7字节=01，数据采集错误，跳过页面和缓存更新`);
                console.log(`🔒 保持当前页面数据不变: 温度=${this.data.temperature}°C, 水位=${this.data.waterLevel}%, 电量=${this.data.batteryLevel}%`);
                
                // 🔄 检查重试次数，避免无限重试
                if (this.data._retryCount < this.data._maxRetryCount) {
                  console.log(`⏰ 3秒后将重新发送0xFF命令获取有效数据... (重试 ${this.data._retryCount + 1}/${this.data._maxRetryCount})`);
                  
                  // 增加重试计数器
                  this.setData({
                    _retryCount: this.data._retryCount + 1,
                    _isRetrying: true
                  });
                  
                  // 延迟3秒后重试
                  const retryTimeoutId = setTimeout(() => {
                    console.log(`🔄 重试获取有效数据... (第${this.data._retryCount}次重试)`);
                    this.retry0xFFCommand();
                  }, 3000);
                  
                  this.setData({
                    _retryTimeoutId: retryTimeoutId
                  });
                  
                  // ⚠️ 重试时不清理pending状态，让retry0xFFCommand可以使用
                  return; // 提前返回，不执行下面的pending清理逻辑
                } else {
                  console.log(`❌ 已达到最大重试次数 (${this.data._maxRetryCount})，停止重试`);
                  console.log(`🔒 保持当前页面数据: 温度=${this.data.temperature}°C, 水位=${this.data.waterLevel}%, 电量=${this.data.batteryLevel}%`);
                  
                  // 达到最大重试次数，响应命令失败
                  this.pendingSync0xFFResolve({
                    ...deviceData,
                    error: '数据采集错误，已达到最大重试次数'
                  });
                  this.clearPendingSync();
                  return;
                }
              }
              
              // 🔓 数据有效时：调用pending resolve并清理
              this.pendingSync0xFFResolve(deviceData);
              this.clearPendingSync();
              
              console.log(`🎯 ${this.pendingSync0xFFAction || '0xFF命令'}响应处理完成`);
            } else {
              // 没有pending命令的情况
              if (isDataValid) {
                // 自动同步收到的有效数据也要更新显示
                console.log('📝 自动同步收到有效数据，更新页面显示');
                this.safeUpdateDeviceData({
                  ...deviceData,
                  lastSyncTime: new Date().toLocaleTimeString()
                }, 'real_data');
                this.cacheDeviceData();
                
                // ✅ 数据有效，清理重试状态，标记解析成功
                if (this.data._retryTimeoutId) {
                  clearTimeout(this.data._retryTimeoutId);
                }
                this.setData({
                  _retryCount: 0,
                  _isRetrying: false,
                  _retryTimeoutId: null,
                  _rawDataParseSuccess: true // 🎯 标记原始数据解析成功
                });
              } else {
                console.log('📝 自动同步收到无效数据，跳过页面更新');
                console.log(`🔒 保持当前页面数据不变: 温度=${this.data.temperature}°C, 水位=${this.data.waterLevel}%, 电量=${this.data.batteryLevel}%`);
                
                // 🔄 对于自动同步的无效数据，也要检查重试次数
                if (this.data._retryCount < this.data._maxRetryCount) {
                  console.log(`⏰ 3秒后将重新发送0xFF命令获取有效数据... (自动重试 ${this.data._retryCount + 1}/${this.data._maxRetryCount})`);
                  
                  // 增加重试计数器
                  this.setData({
                    _retryCount: this.data._retryCount + 1,
                    _isRetrying: true
                  });
                  
                  // 延迟3秒后重试
                  const retryTimeoutId = setTimeout(() => {
                    console.log(`🔄 自动重试获取有效数据... (第${this.data._retryCount}次重试)`);
                    this.syncData(); // 自动同步使用syncData而不是retry0xFFCommand
                  }, 3000);
                  
                  this.setData({
                    _retryTimeoutId: retryTimeoutId
                  });
                } else {
                  console.log(`❌ 自动同步已达到最大重试次数 (${this.data._maxRetryCount})，停止重试`);
                  console.log(`🔒 保持当前页面数据: 温度=${this.data.temperature}°C, 水位=${this.data.waterLevel}%, 电量=${this.data.batteryLevel}%`);
                }
              }
            }
          } else {
            console.log('❌ 数据字节长度不足，无法解析');
          }
        } else {
          console.log('❌ 数据长度不足，无法解析');
        }
      }
    } catch (error) {
      console.error('❌ 解析十六进制数据失败:', error);
    }
  },

  // 🆕 发送0xFF命令的核心方法
  send0xFFCommand(actionName: string): Promise<any> {
    return new Promise((resolve, reject) => {
      try {
        console.log(`${actionName} - 开始发送0xFF命令...`);
        
        // 🔧 检查是否有pending命令正在执行
        if (this.pendingSync0xFFResolve) {
          console.log(`${actionName} - 检测到有pending命令正在执行，取消当前请求`);
          reject(new Error('有其他同步命令正在执行中'));
          return;
        }
        
        // 🎯 设置pending resolve，让原始数据解析可以直接返回成功
        this.pendingSync0xFFResolve = resolve;
        this.pendingSync0xFFReject = reject;
        this.pendingSync0xFFAction = actionName;
        
        // 🔒 重置重试计数器
        this.setData({
          _retryCount: 0
        });
        
        // 🔧 添加超时计时器引用，让重试机制能够重置它
        let timeoutId: any = null;
        
        const resetTimeout = () => {
          if (timeoutId) {
            clearTimeout(timeoutId);
          }
          // 🎯 每次重试都重置超时计时器，给重试机制足够时间
          timeoutId = setTimeout(() => {
            if (this.pendingSync0xFFResolve) {
              console.log(`${actionName} - 清理pending resolve（命令超时）`);
              this.pendingSync0xFFReject && this.pendingSync0xFFReject(new Error('命令执行超时'));
              this.clearPendingSync();
            }
          }, 30000);
        };
        
        // 🆕 将重置超时的方法保存到实例中，供重试机制使用
        (this as any)._reset0xFFTimeout = resetTimeout;
        
        // 检查设备连接状态
        if (!RCSPManager || !RCSPManager.isConnectedDevce()) {
          this.clearPendingSync();
          reject(new Error('设备未连接'));
          return;
        }

        // 获取当前RCSP操作包装器
        const rcspWrapperContainer = RCSPManager.getCurrentRcspOperateWrapper();
        if (!rcspWrapperContainer || !rcspWrapperContainer.wrapper) {
          this.clearPendingSync();
          reject(new Error('RCSP包装器不可用'));
          return;
        }

        const rcspWrapper = rcspWrapperContainer.wrapper;
        const rcspOpImpl = rcspWrapper.getRcspOpImpl();
        if (!rcspOpImpl) {
          this.clearPendingSync();
          reject(new Error('RCSP实现未初始化'));
          return;
        }

        const device = rcspOpImpl.getUsingDevice();
        if (!device) {
          this.clearPendingSync();
          reject(new Error('没有正在使用的设备'));
          return;
        }

        // 🔧 发送设备重置命令（清理设备状态）
        this.sendDeviceResetCommand(rcspOpImpl, device)
          .then(() => {
            // 重置成功后，发送0xFF命令
            return this.sendActual0xFFCommand(rcspOpImpl, device, actionName);
          })
          .catch((error) => {
            console.log(`${actionName} - 设备重置失败，直接发送0xFF命令:`, error);
            // 即使重置失败，也尝试发送0xFF命令
            return this.sendActual0xFFCommand(rcspOpImpl, device, actionName);
          });
        
        // 🎯 启动初始超时计时器
        resetTimeout();
        
      } catch (error) {
        console.error(`${actionName} - 发送0xFF命令异常:`, error);
        this.clearPendingSync();
        reject(error);
      }
    });
  },

  // 🆕 清理pending同步状态
  clearPendingSync() {
    // 🆕 清理超时计时器引用
    if ((this as any)._reset0xFFTimeout) {
      (this as any)._reset0xFFTimeout = null;
    }
    
    // 🔒 清理重试状态
    if (this.data._retryTimeoutId) {
      clearTimeout(this.data._retryTimeoutId);
    }
    
    this.setData({
      _isRetrying: false,
      _retryTimeoutId: null,
      _retryCount: 0 // 重置重试次数
    });
    
    this.pendingSync0xFFResolve = null;
    this.pendingSync0xFFReject = null;
    this.pendingSync0xFFAction = null;
  },

  // 🆕 重试0xFF命令（当数据无效时）
  retry0xFFCommand() {
    try {
      console.log('🔄 [retry0xFFCommand] 开始重试0xFF命令');
      
      // 检查是否还有pending的同步请求
      if (!this.pendingSync0xFFResolve) {
        console.log('⚠️ [retry0xFFCommand] 没有pending的同步请求，跳过重试');
        return;
      }
      
      // 检查设备连接状态
      if (!RCSPManager || !RCSPManager.isConnectedDevce()) {
        console.log('❌ [retry0xFFCommand] 设备未连接，重试失败');
        this.pendingSync0xFFReject && this.pendingSync0xFFReject(new Error('设备未连接'));
        this.clearPendingSync();
        return;
      }

      // 获取当前RCSP操作包装器
      const rcspWrapperContainer = RCSPManager.getCurrentRcspOperateWrapper();
      if (!rcspWrapperContainer || !rcspWrapperContainer.wrapper) {
        console.log('❌ [retry0xFFCommand] RCSP包装器不可用，重试失败');
        this.pendingSync0xFFReject && this.pendingSync0xFFReject(new Error('RCSP包装器不可用'));
        this.clearPendingSync();
        return;
      }

      const rcspWrapper = rcspWrapperContainer.wrapper;
      const rcspOpImpl = rcspWrapper.getRcspOpImpl();
      if (!rcspOpImpl) {
        console.log('❌ [retry0xFFCommand] RCSP实现未初始化，重试失败');
        this.pendingSync0xFFReject && this.pendingSync0xFFReject(new Error('RCSP实现未初始化'));
        this.clearPendingSync();
        return;
      } 

      const device = rcspOpImpl.getUsingDevice();
      if (!device) {
        console.log('❌ [retry0xFFCommand] 没有正在使用的设备，重试失败');
        this.pendingSync0xFFReject && this.pendingSync0xFFReject(new Error('没有正在使用的设备'));
        this.clearPendingSync();
        return;
      }

      console.log('🔄 [retry0xFFCommand] 重新发送0xFF命令');
      
      // 🆕 重置超时计时器，给重试更多时间
      if ((this as any)._reset0xFFTimeout) {
        console.log('🔄 [retry0xFFCommand] 重置超时计时器');
        (this as any)._reset0xFFTimeout();
      }
      
      // 重新发送0xFF命令（不重置设备，直接发送0xFF）
      this.sendActual0xFFCommand(rcspOpImpl, device, this.pendingSync0xFFAction || '重试0xFF命令')
        .then(() => {
          console.log('✅ [retry0xFFCommand] 重试命令发送成功');
          // 🔒 重试命令发送成功后，清理重试状态（但保留pending状态等待数据）
          this.setData({
            _isRetrying: false
          });
        })
        .catch((error) => {
          console.error('❌ [retry0xFFCommand] 重试命令发送失败:', error);
          this.pendingSync0xFFReject && this.pendingSync0xFFReject(error);
          this.clearPendingSync();
        });
        
    } catch (error) {
      console.error('❌ [retry0xFFCommand] 重试0xFF命令异常:', error);
      this.pendingSync0xFFReject && this.pendingSync0xFFReject(error);
      this.clearPendingSync();
    }
  },

  // 🆕 发送设备重置命令
  sendDeviceResetCommand(rcspOpImpl: any, device: any): Promise<void> {
    return new Promise((resolve, reject) => {
      try {
        console.log('🔄 发送设备重置命令...');
        
        // 导入必要的类
        const { CmdCustom, ParamBase } = require('../../jl_lib/jl-rcsp/jl_rcsp_watch_1.1.0');

        // 创建重置参数对象
        class ResetParam extends ParamBase {
          basePayload: Uint8Array;
          
          constructor() {
            super();
            this.basePayload = new Uint8Array([0x00]); // 发送0x00作为重置命令
          }
          
          toData() {
            return this.basePayload;
          }
          
          parseData(data: any) {
            this.basePayload = data;
            return data.length;
          }
        }

        const resetParam = new ResetParam();
        const resetCommand = new CmdCustom(resetParam);
        resetCommand.setOpCode(0x00); // 设置操作码为0x00

        // 重置命令回调
        const resetCallback = {
          onCmdResponse: (device: any, command: any) => {
            console.log('✅ 设备重置命令响应成功');
            resolve();
          },
          onError: (device: any, code: number, message: string) => {
            console.log('⚠️ 设备重置命令失败（继续执行）:', code, message);
            // 即使重置失败也继续执行
            resolve();
          }
        };

        // 发送重置命令
        rcspOpImpl.sendRCSPCommand(
          device,
          resetCommand,
          1000, // 1秒超时
          resetCallback
        );
        
        // 1.2秒后强制resolve，避免阻塞
        setTimeout(() => {
          console.log('🔄 设备重置命令超时，继续执行');
          resolve();
        }, 1200);
        
      } catch (error) {
        console.log('🔄 设备重置命令异常（继续执行）:', error);
        resolve(); // 异常时也继续执行
      }
    });
  },

  // 🆕 发送实际的0xFF命令
  sendActual0xFFCommand(rcspOpImpl: any, device: any, actionName: string): Promise<void> {
    return new Promise((resolve, reject) => {
      try {
        console.log(`${actionName} - 发送实际0xFF命令...`);
        
        // 导入必要的类
        const { CmdCustom, ParamBase } = require('../../jl_lib/jl-rcsp/jl_rcsp_watch_1.1.0');

        // 创建参数对象
        class SimpleParam extends ParamBase {
          basePayload: Uint8Array;
          
          constructor() {
            super();
            this.basePayload = new Uint8Array([0xFF]); // 🔑 关键：发送0xFF
          }
          
          toData() {
            return this.basePayload || new Uint8Array([0xFF]);
          }
          
          parseData(data: any) {
            this.basePayload = data;
            return data.length;
          }
        }

        const param = new SimpleParam();
        const customCommand = new CmdCustom(param);
        customCommand.setOpCode(0xFF); // 🔑 设置操作码为0xFF

        // 命令回调处理
        const commandCallback = {
          onCmdResponse: (device: any, command: any) => {
            console.log(`${actionName} - 收到RCSP命令响应（可能已被原始数据解析处理）`);
            
            // 如果原始数据解析还没处理，这里作为备用
            if (this.pendingSync0xFFResolve) {
              const response = command.getResponse();
              if (response) {
                const payload = response.getPayload();
                if (payload && payload.length >= 2) {
                  const deviceData = {
                    waterLevel: payload[0],
                    temperature: payload[1],
                    batteryLevel: payload[2] || this.data.batteryLevel
                  };
                  this.pendingSync0xFFResolve(deviceData);
                } else {
                  this.pendingSync0xFFResolve(null);
                }
                this.clearPendingSync();
              }
            }
            resolve();
          },
          onError: (device: any, code: number, message: string) => {
            console.log(`${actionName} - RCSP命令错误，检查原始数据解析状态:`, code, message);
            
            // 🎯 给原始数据监听器一些时间完成解析（针对时序问题）
            setTimeout(() => {
              if (this.pendingSync0xFFReject) {
                // 检查是否有原始数据解析成功的标记
                if (this.data._rawDataParseSuccess) {
                  console.log(`✅ ${actionName} - 虽然RCSP超时，但原始数据解析成功，视为成功`);
                  
                  // 构造设备数据并resolve
                  const deviceData = {
                    temperature: this.data.temperature,
                    waterLevel: this.data.waterLevel,
                    drinkAmount: this.data.drinkAmount,
                    batteryLevel: this.data.batteryLevel
                  };
                  
                  this.pendingSync0xFFResolve?.(deviceData);
                  this.clearPendingSync();
                } else {
                  console.log(`❌ ${actionName} - RCSP超时且原始数据解析失败`);
                  this.pendingSync0xFFReject?.(new Error(`命令执行失败: ${message}`));
                  this.clearPendingSync();
                }
              } else {
                console.log(`${actionName} - 原始数据解析已成功，忽略RCSP错误`);
              }
            }, 300); // 给300ms时间让原始数据监听器完成处理
            
            resolve(); // 即使出错也resolve，让外层处理
          }
        };

        // 发送RCSP命令
        rcspOpImpl.sendRCSPCommand(
          device,
          customCommand,
          2000, // 2秒超时
          commandCallback
        );
        
        resolve();
        
      } catch (error) {
        console.error(`${actionName} - 发送实际0xFF命令异常:`, error);
        reject(error);
      }
    });
  },

  // 同步数据 - 🔥 新的核心实现
  async syncData() {
    this.ensureLang();
    console.log('🚀 [syncData] 开始同步数据流程');
    
    // 🔓 手动同步时先解锁数据，允许更新
    this.unlockDeviceData();
    
    // 🎯 重置原始数据解析成功标记
    this.setData({
      _rawDataParseSuccess: false
    });
    
    // 🔧 添加防抖机制，避免重复点击
    const now = Date.now();
    if (this._lastManualSyncTime && (now - this._lastManualSyncTime) < 5000) {
      console.log('⚠️ [syncData] 防抖：距离上次手动同步不足5秒，显示上次同步结果');
      
      // 🎯 使用上一次同步的数据，但保持原始提示
      if ((this as any)._lastSyncResult) {
        const { success, data, message, timestamp } = (this as any)._lastSyncResult;
        
        if (success && data) {
          // 显示原始成功提示
          wx.showToast({
            title: i18n.t('device.syncToast'),
            icon: 'success'
          });
          
          // 更新显示上次同步的数据
          this.setData({
            waterLevel: data.waterLevel || this.data.waterLevel,
            temperature: data.temperature || this.data.temperature,
            batteryLevel: data.batteryLevel || this.data.batteryLevel,
            drinkAmount: data.drinkAmount || this.data.drinkAmount,
            lastSyncTime: new Date(timestamp).toLocaleString()
          });
          
          console.log('✅ [syncData] 使用缓存数据，保持原始提示体验:', data);
        } else {
          // 显示原始失败提示
          wx.showToast({
            title: i18n.t('device.syncToastFailed'),
            icon: 'none'
          });
          
          console.log('❌ [syncData] 使用缓存失败状态，保持原始提示');
        }
      } else {
        // 如果没有上次同步记录，显示原始提示
        wx.showToast({
          title: i18n.t('device.loadingDeviceData'),
          icon: 'none'
        });
      }
      return;
    }
    
    // 🔧 设备命令间隔控制，避免设备处理冲突
    if (this._lastDeviceCommandTime && (now - this._lastDeviceCommandTime) < 1500) {
      console.log('⚠️ [syncData] 设备命令间隔不足1.5秒，延迟执行');
      setTimeout(() => {
        this.syncData();
      }, 1500 - (now - this._lastDeviceCommandTime));
      return;
    }
    
    this._lastManualSyncTime = now;
    this._lastDeviceCommandTime = now;
    
    if (!this.data.isLoggedIn) {
      console.log('❌ [syncData] 用户未登录');
      wx.showToast({
        title: i18n.t('device.needLogin'),
        icon: 'none'
      });
      return;
    }

    // 🔧 如果没有设备，尝试刷新设备状态
    if (!this.data.hasDevice) {
      console.log('🔍 [syncData] 检测到无设备，尝试刷新设备状态...');
      await this.checkDeviceStatusUpdate();
      
      // 再次检查设备状态
      if (!this.data.hasDevice) {
        console.log('❌ [syncData] 确认无设备');
        wx.showToast({
          title: i18n.t('device.pleaseConnect'),
          icon: 'none'
        });
        return;
      }
    }

    // 🔧 智能检查设备连接状态
    const curId = RCSPManager.getCurrentRcspOperateWrapper()?.deviceId || '';
    const bluetoothConnected = curId !== '';
    
    console.log('🔍 [syncData] 连接状态检查:', {
      dataIsConnected: this.data.isConnected,
      bluetoothConnected,
      currentRcspId: curId
    });
    
    // 如果蓝牙实际已连接但页面状态未同步，先更新状态
    if (bluetoothConnected && !this.data.isConnected) {
      console.log('🔄 [syncData] 检测到蓝牙已连接但页面状态未同步，更新状态');
      this.setData({
        isConnected: true
      });
    }
    
    // 检查最终连接状态
    if (!bluetoothConnected && !this.data.isConnected) {
      console.log('❌ [syncData] 设备未连接');
      wx.showToast({
        title: i18n.t('device.pleaseConnect'),
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: i18n.t('device.loadingDeviceData')
    });

    console.log('📡 [syncData] 发送0xFF命令获取设备数据');

    // 🔓 手动同步时临时设置原始数据监听器
    this.setupRawDataListener();

    // 发送0xFF命令获取设备最新数据
    this.send0xFFCommand('同步数据')
      .then((deviceData) => {
        console.log('✅ [syncData] 设备数据获取成功:', deviceData);
        wx.hideLoading();
        
        // 🎯 显示完整的设备状态信息
        const waterLevel = deviceData?.waterLevel || this.data.waterLevel || 0;
        const temperature = deviceData?.temperature || this.data.temperature || '--';
        const batteryLevel = deviceData?.batteryLevel || this.data.batteryLevel || 0;
        const drinkAmount = deviceData?.drinkAmount || this.data.drinkAmount || 0;
        
        wx.showToast({
          title: i18n.t('device.syncResultToast', { waterLevel, temperature, batteryLevel, drinkAmount }),
          icon: 'success',
          duration: 3000
        });
        
        // 🔄 保存同步成功的结果
        (this as any)._lastSyncResult = {
          success: true,
          data: {
            waterLevel: waterLevel,
            temperature: temperature,
            batteryLevel: batteryLevel,
            drinkAmount: drinkAmount
          },
          message: `同步成功: 水位${waterLevel}%, 温度${temperature}°C`,
          timestamp: Date.now()
        };
        
        // 🆕 数据同步成功后，同步时间
        if (RCSPOpAlarm) {
          RCSPOpAlarm.syncTime(new Date()).then(() => {
            console.log('⏰ 时间同步成功');
          }).catch((error) => {
            console.log('⏰ 时间同步失败:', error);
          });
        }
        
        // 🆕 同步完成后，重新加载后端设备数据
        setTimeout(() => {
          this.loadDeviceData();
        }, 1000);
        
        // 🔓 手动同步完成后清理原始数据监听器
        this.cleanupRawDataListener();
      })
      .catch((error) => {
        console.error('数据同步失败:', error);
        wx.hideLoading();
        wx.showToast({
          title: i18n.t('device.syncToastFailed'),
          icon: 'none'
        });
        
        // 🔄 保存同步失败的结果
        (this as any)._lastSyncResult = {
          success: false,
          data: null,
          message: '同步失败，请重试',
          timestamp: Date.now()
        };
        
        // 🔓 同步失败时也要清理原始数据监听器
        this.cleanupRawDataListener();
      });
  },

  // 设备闹钟设置 - 跳转到闹钟管理页面
  deviceSettings() {
    console.log('跳转到闹钟管理页面');
    
    // 检查是否有设备连接
    if (!this.data.isConnected) {
      wx.showToast({
        title: i18n.t('device.pleaseConnect'),
        icon: 'none'
      });
      return;
    }
    
    // 跳转到闹钟管理页面
    wx.navigateTo({
      url: '/pages/function_test/pageAlarmClock/pageAlarmClock',
      fail: (error) => {
        console.error('跳转闹钟管理页面失败:', error);
        wx.showToast({ title: i18n.t('device.jumpFailed'), icon: 'error' });
      }
    });
  },

  // 重置设备设置
  resetDeviceSettings() {
    wx.showModal({
      title: '重置设备设置',
      content: '确定要重置所有设备设置吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            reminderEnabled: true,
            temperatureEnabled: true,
            autoSync: true
          });
          wx.showToast({
            title: '设置已重置',
            icon: 'success'
          });
        }
      }
    });
  },

  // 显示设备详情
  showDeviceDetails() {
    const device = this.data.currentDevice;
    wx.showModal({
      title: '设备详情',
      content: `设备ID: ${device.deviceId}\n设备名称: ${device.name}\n连接状态: ${this.data.isConnected ? '已连接' : '未连接'}\n电量: ${this.data.batteryLevel}%\n水位: ${this.data.waterLevel}%`,
      showCancel: false
    });
  },

  // 设备诊断
  deviceDiagnosis() {
    wx.showLoading({ title: i18n.t('device.diagnosisLoading') });
    
    setTimeout(() => {
      wx.hideLoading();
      wx.showModal({
        title: '诊断结果',
        content: '设备状态正常\n✓ 蓝牙连接正常\n✓ 传感器工作正常\n✓ 电池状态良好',
        showCancel: false
      });
    }, 2000);
  },

  // 删除设备
  async deleteDevice() {
    this.ensureLang();
    console.log('删除设备');
    
    if (!this.data.hasDevice) {
      wx.showToast({
        title: i18n.t('device.deleteNoDevice'),
        icon: 'none'
      });
      return;
    }
    
    wx.showModal({
      title: i18n.t('device.deleteConfirmTitle'),
      content: i18n.t('device.deleteConfirmContent'),
      confirmText: this._btn(i18n.t('device.actionDelete'), 'OK'),
      cancelText: this._btn(i18n.t('common.cancel'), 'Back'),
      confirmColor: '#ef4444',
      success: async (res) => {
        if (res.confirm) {
          this.performDeleteDevice();
        }
      }
    });
  },

  // 执行删除设备操作
  async performDeleteDevice() {
    this.ensureLang();
    wx.showLoading({ title: i18n.t('device.deleting') });
    
    try {
      const deviceIdToDelete = this.data.currentDevice.deviceId;
      console.log('开始删除设备，设备ID:', deviceIdToDelete);
      
      if (!deviceIdToDelete) {
        throw new Error('设备ID为空');
      }
      
      // 获取当前用户信息
      const userProfile = await api.getUserInfo();
      const userId = userProfile?.data?.data?.id || userProfile?.data?.id;
      
      if (!userId) {
        throw new Error('无法获取用户ID');
      }
      
      console.log('获取到用户ID:', userId);
      
      // 获取设备列表找到对应的deviceSn
      const devicesResponse = await api.getDevices();
      const deviceList = devicesResponse?.data?.data || devicesResponse?.data || [];
      
      // 找到当前设备获取deviceSn
      const device = deviceList.find((d: any) => 
        (d.deviceId || d.deviceSn) === deviceIdToDelete
      );
      
      if (!device) {
        throw new Error('未找到要删除的设备');
      }
      
      const deviceSn = device.deviceSn || device.deviceId;
      console.log('使用deviceSn进行删除:', deviceSn);
      
      // 调用真正的删除设备API（完全删除记录）
      const deleteResponse = await api.deleteDevice(userId, deviceSn);
      console.log('删除设备API响应:', deleteResponse);
      
      // 检查响应状态
      if (deleteResponse && deleteResponse.statusCode === 200) {
        const responseData = deleteResponse.data;
        if (responseData && (responseData.code === "200" || responseData.code === 200)) {
          console.log('设备删除成功');
        } else {
          throw new Error(responseData?.message || '删除失败');
        }
      } else {
        throw new Error(`删除请求失败，状态码: ${deleteResponse?.statusCode}`);
      }
      
      // 🔧 删除成功后断开蓝牙连接
      try {
        console.log('🔌 开始断开蓝牙连接...');
        
        // 获取当前连接的设备信息
        const rcspOperateWrapper = RCSPManager.getCurrentRcspOperateWrapper();
        if (rcspOperateWrapper && rcspOperateWrapper.wrapper) {
          const rcspOpImpl = rcspOperateWrapper.wrapper.getRcspOpImpl();
          if (rcspOpImpl) {
            const connectedDevice = rcspOpImpl.getUsingDevice();
            if (connectedDevice) {
              console.log('🔌 找到已连接设备，准备断开:', connectedDevice.deviceId);
              
              // 创建BluetoothDevice对象用于断开连接
              const bluetoothDevice = new BluetoothDevice();
              bluetoothDevice.deviceId = connectedDevice.deviceId;
              bluetoothDevice.name = connectedDevice.name || '智能水杯';
              bluetoothDevice.localName = connectedDevice.name || '智能水杯';
              bluetoothDevice.RSSI = 0;
              bluetoothDevice.connectable = true;
              bluetoothDevice.serviceData = {};
              
              // 调用断开设备连接的方法（参考index_test页面逻辑）
              DeviceManager.disconnectDevice(bluetoothDevice);
              
              console.log('🔌 蓝牙断开连接命令已发送');
            } else {
              console.log('🔌 没有找到连接的设备对象');
            }
          } else {
            console.log('🔌 RCSP实现未初始化');
          }
        } else {
          console.log('🔌 没有当前连接的RCSP包装器');
        }
      } catch (disconnectError) {
        console.error('🔌 断开蓝牙连接失败:', disconnectError);
        // 即使断开失败也不影响删除流程，只记录错误
      }
      
      // 清理本地状态
      this.setData({
        hasDevice: false,
        currentDevice: {
          deviceId: 'SWB-2024',
          name: '智能水杯Pro'
        },
        isConnected: false,
        waterLevel: 0,
        temperature: '--',
        batteryLevel: 0,
        capacity: 600
      });
      
      wx.hideLoading();
      wx.showToast({
      title: i18n.t('device.deleteSuccess'),
      icon: 'success'
    });
      
      console.log('设备删除完成');
      
    } catch (error) {
      console.error('删除设备失败:', error);
      wx.hideLoading();
      
      let errorMessage = '删除设备失败';
      if (error instanceof Error) {
        if (error.message.includes('未找到')) {
          errorMessage = '设备不存在或已被删除';
        } else if (error.message.includes('用户ID')) {
          errorMessage = '获取用户信息失败，请重新登录';
        } else if (error.message) {
          errorMessage = error.message;
        }
      }
      
      wx.showToast({
        title: errorMessage,
        icon: 'none',
        duration: 3000
      });
    }
  },

  // 检查温度 - 🔥 使用0xFF命令获取真实温度
  checkTemperature() {
    this.ensureLang();
    console.log('��️ [checkTemperature] 开始检测温度');
    
    // 🔧 添加防抖机制，避免重复点击
    const now = Date.now();
    if (this._lastManualSyncTime && (now - this._lastManualSyncTime) < 5000) {
      console.log('⚠️ [checkTemperature] 防抖：距离上次检测不足5秒，显示上次检测结果');
      
      // 🎯 使用上一次温度检测的结果，但保持原始提示
      if ((this as any)._lastTempResult) {
        const { success, temperature, message, timestamp } = (this as any)._lastTempResult;
        
        if (success && temperature) {
          // 显示原始成功提示
          wx.showToast({
        title: i18n.t('device.temperatureCheckSuccess'),
        icon: 'success'
      });
          
          // 更新显示上次检测的温度
          this.setData({
            temperature: temperature
          });
          
          console.log('✅ [checkTemperature] 使用缓存温度，保持原始提示体验:', temperature);
        } else {
          // 显示原始失败提示
          wx.showToast({
        title: i18n.t('device.temperatureCheckFailed'),
        icon: 'none'
      });
          
          console.log('❌ [checkTemperature] 使用缓存失败状态，保持原始提示');
        }
      } else {
        // 显示原始提示
        wx.showToast({
        title: i18n.t('device.temperatureChecking'),
        icon: 'none'
      });
      }
      return;
    }
    
    // 🔧 设备命令间隔控制，避免设备处理冲突
    if (this._lastDeviceCommandTime && (now - this._lastDeviceCommandTime) < 1500) {
      console.log('⚠️ [checkTemperature] 设备命令间隔不足1.5秒，延迟执行');
      setTimeout(() => {
        this.checkTemperature();
      }, 1500 - (now - this._lastDeviceCommandTime));
      return;
    }
    
    this._lastDeviceCommandTime = now;
    
    if (!this.data.isLoggedIn || !this.data.hasDevice) {
      wx.showToast({
        title: i18n.t('device.needLogin'),
        icon: 'none'
      });
      return;
    }

    // 检查设备连接状态
    if (!this.data.isConnected) {
      wx.showToast({
        title: i18n.t('device.pleaseConnect'),
        icon: 'none'
      });
      return;
    }

          wx.showLoading({
      title: i18n.t('device.temperatureChecking')
    });

    // 🎯 使用0xFF命令获取真实温度数据
    this.send0xFFCommand('检查温度')
      .then((deviceData) => {
        wx.hideLoading();
        
        if (deviceData && deviceData.batteryLevel !== undefined) {
          // 🔋 专门为设备状态检测显示弹窗
          const waterLevel = deviceData.waterLevel || this.data.waterLevel || 0;
          const temperature = deviceData.temperature || this.data.temperature || '--';
          const drinkAmount = deviceData.drinkAmount || this.data.drinkAmount || 0;
          
          wx.showModal({
      title: i18n.t('device.deviceStatusTitle'),
      content: `${i18n.t('device.statusWaterLabel')}${waterLevel}%\n${i18n.t('device.statusTempLabel')}${temperature}°C\n${i18n.t('device.statusDrinkLabel')}${drinkAmount}ml\n${i18n.t('device.statusBatteryLabel')}${deviceData.batteryLevel}%\n${i18n.t('device.statusConnNormal')}\n${i18n.t('device.statusLastSync')}${this.data.lastSyncTime}`,
      showCancel: false,
      confirmText: i18n.t('common.ok')
    });
          
          // 🔄 保存温度检测成功的结果
          (this as any)._lastTempResult = {
            success: true,
            temperature: temperature,
            message: `温度检测成功: ${temperature}°C`,
            timestamp: Date.now()
          };
          
          console.log('✅ [checkTemperature] 设备状态检测完成，数据已更新');
        } else {
                  wx.showToast({
          title: i18n.t('device.stateFailed'),
          icon: 'none'
        });
          
          // 🔄 保存温度检测失败的结果
          (this as any)._lastTempResult = {
            success: false,
            temperature: null,
            message: '设备状态获取失败',
            timestamp: Date.now()
          };
        }
      })
      .catch((error) => {
        console.error('检测温度失败', error);
        wx.hideLoading();
        wx.showToast({
          title: i18n.t('device.detectFailed'),
          icon: 'none'
        });
        
        // 🔄 保存温度检测失败的结果
        (this as any)._lastTempResult = {
          success: false,
          temperature: null,
          message: '检测失败，请重试',
          timestamp: Date.now()
        };
      });
  },

  // 饮水提醒功能已移除

  // profile页面设置状态同步功能已移除

  // 🔓 手动解锁数据（用于用户主动刷新）
  unlockDeviceData() {
    console.log('🔓 [unlockDeviceData] 手动解锁设备数据');
    this.setData({ 
      _dataLocked: false,
      _lastRealDataTime: 0
    });
  },

  // 消息通知设置功能已移除

  // 切换自动同步（本地设置）
  toggleAutoSync() {
    const enabled = !this.data.autoSync;
    
    this.setData({
      autoSync: enabled
    });
    
    wx.showToast({
      title: enabled ? '自动同步已开启' : '自动同步已关闭',
      icon: 'success'
    });
    
    console.log('自动同步状态:', enabled);
      },

  // 本地化设备名称
  localizeDeviceName(raw: string): string {
    if (!raw) return '';
    const map = (i18n.getDict() as any)?.device?.nameMap || {};
    // 精确匹配或大小写无关匹配
    if (map[raw]) return map[raw];
    const lower = raw.toLowerCase();
    for (const k in map) {
      if (k.toLowerCase() === lower) return map[k];
    }
    return raw;
  },
 
  // 同步RCSP连接状态
  syncRCSPConnectionStatus() {
    try {
      // 从当前 RCSP 上下文获取真实的连接状态
      const curId = RCSPManager.getCurrentRcspOperateWrapper()?.deviceId || '';
      const actuallyConnected = curId !== '';
      
      console.log('同步RCSP连接状态:', {
        currentDeviceId: curId,
        isConnected: actuallyConnected
      });
      
      // 更新连接状态和设备ID（如果已连接）
      this.setData({
        isConnected: actuallyConnected,
        'currentDevice.deviceId': actuallyConnected ? curId : this.data.currentDevice.deviceId
      });
    } catch (e) {
      console.error('同步RCSP连接状态失败:', e);
    }
  },

  // 下拉刷新
  onPullDownRefresh() {
    console.log('🔄 设备页面下拉刷新');
    // 🔓 解锁数据，允许刷新
    this.unlockDeviceData();
    
    // 重新加载设备数据
    this.loadDeviceData().finally(() => {
      wx.stopPullDownRefresh();
    });
  },

  // 跳转到指纹录入页面
  goToLockControlUsers() {
    console.log('跳转到指纹录入页面');
    
    // 检查设备连接状态
    const curId = RCSPManager.getCurrentRcspOperateWrapper()?.deviceId || '';
    const isConnected = curId !== '';
    
    if (!isConnected) {
      wx.showToast({
        title: '请先连接设备',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    // 传递当前设备ID
    wx.navigateTo({
      url: `/pages/lockControlUsers/lockControlUsers?did=${curId}`,
      success: () => {
        console.log('成功跳转到指纹录入页面');
      },
      fail: (err) => {
        console.error('跳转指纹录入页面失败:', err);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none'
        });
      }
    });
  },

  // 统一限制弹窗按钮文本长度（微信限制最多4个字符）
  _btn(text: string, fallback: string) {
    const v = (text && String(text)) || fallback;
    return v.length > 4 ? v.slice(0, 4) : v;
  },

  // 确保当前 i18n 语言与存储一致
  ensureLang() {
    try {
      const saved = wx.getStorageSync('app:lang');
      const get = i18n.getLang && i18n.getLang();
      if (saved && saved !== get && i18n.setLang) {
        i18n.setLang(saved);
      }
    } catch (_) {}
  },
});
